//app.js
// 导入API服务
const apiService = require('./utils/api.js');

App({
  api: apiService,
  globalData: {
    isFirstVisit: true,
    selectedMoods: ['放松'],
    hasDrawnToday: false,
    bonusDrawCount: 0,
    contributionStatus: 'pending',
    drawResultType: '',
    shareOpened: false,
    historyData: [],
    userInfo: {
      avatar: '',
      nickname: '用户',
      consecutiveDays: 1,
      totalSubmissions: 0,
      favorites: 0
    },
    // 缓存数据，减少请求次数
    cachedData: {
      drawHistory: [],
      submissions: []
    }
  },

  onLaunch: function () {
    // 检查是否首次访问（本地存储）
    const isFirst = wx.getStorageSync('isFirstVisit');
    if (isFirst === false) {
      this.globalData.isFirstVisit = false;
    }
    
    // 初始化数据
    this.initializeData();
  },

  onShow: function() {
    // 每次应用显示时从后端获取最新数据
    this.refreshData();
  },

  // 初始化数据
  initializeData: function() {
    // API服务已在App对象中初始化
    try {
      // 从后端加载用户信息
      this.loadUserInfo();
      // 从后端加载抽奖状态
      this.checkDrawStatus();
      // 从后端加载历史数据
      this.loadDrawHistory();
    } catch (error) {
      console.error('初始化数据失败:', error);
      // 初始化失败时，显示错误提示
      wx.showToast({
        title: '网络连接失败，使用本地模式',
        icon: 'none'
      });
      // 回退到本地模式
      this.initializeLocalMode();
    }
  },

  // 刷新数据
  async refreshData() {
    try {
      await Promise.all([
        this.loadUserInfo(),
        this.checkDrawStatus()
      ]);
    } catch (error) {
      console.error('刷新数据失败:', error);
    }
  },

  // 检查今日抽奖状态（从后端）
  async checkDrawStatus() {
    try {
      const status = await apiService.checkDrawStatus();
      this.globalData.hasDrawnToday = status.hasDrawnToday || false;
      this.globalData.bonusDrawCount = status.bonusDrawCount || 0;
    } catch (error) {
      console.error('检查抽奖状态失败:', error);
      // 失败时尝试本地模式
      this.checkLocalDrawStatus();
    }
  },

  // 记录今日抽奖（调用后端API）
  async recordDraw() {
    try {
      // 执行抽奖操作，由后端记录
      const result = await apiService.performDraw(this.globalData.selectedMoods);
      if (result.success) {
        this.globalData.hasDrawnToday = true;
        
        // 保存结果到历史记录（会自动进行数据格式转换）
        const savedRecord = await this.saveDrawHistory(result.data);
        
        // 同时更新全局数据，用于页面显示
        if (savedRecord) {
          this.globalData.drawResult = savedRecord;
          this.globalData.drawResultType = savedRecord.type;
        }
        
        // 返回包含historyId的完整对象，确保与后端API返回格式一致
        // 优先使用historyId字段，其次是id字段
        return {
          id: result.data.historyId || result.data.id || Date.now().toString(),
          historyId: result.data.historyId,
          ...result.data
        };
      }
      return null;
    } catch (error) {
      console.error('记录抽奖失败:', error);
      // 失败时尝试本地模式
      return this.recordLocalDraw();
    }
  },

  // 使用额外抽奖次数（调用后端API）
  async useBonusDraw() {
    try {
      const result = await apiService.performBonusDraw();
      if (result.success) {
        this.globalData.bonusDrawCount = result.bonusDrawCount;
        // 保存结果到历史记录
        this.saveDrawHistory(result.data);
        
        // 返回包含historyId的完整对象，确保与后端API返回格式一致
        // 优先使用historyId字段，其次是id字段
        return {
          id: result.data.historyId || result.data.id || Date.now().toString(),
          historyId: result.data.historyId,
          ...result.data
        };
      }
      return null;
    } catch (error) {
      console.error('使用额外抽奖次数失败:', error);
      // 失败时尝试本地模式
      return this.useLocalBonusDraw();
    }
  },

  // 保存历史记录（调用后端API）
  async saveDrawHistory(result) {
    try {
      // 后端会自动保存抽奖历史，这里只更新本地缓存
      
      // 处理content数据格式转换
      let formattedContent = {};
      if (result.content) {
        // 检查是否存在payload对象（后端API返回格式）
        if (result.content.payload) {
          formattedContent = {
            title: result.content.payload.title || '标题',
            content: result.content.payload.body || '内容',
            tags: result.content.tags || [],
            source: result.content.source || '系统'
          };
        } else {
          // 直接使用content对象（兼容其他格式）
          formattedContent = result.content;
        }
      } else if (typeof result === 'object') {
        // 处理本地模式或其他格式的抽奖结果
        formattedContent = {
          content: result.content || '',
          title: '',
          tags: [],
          source: '本地模式'
        };
      }
      
      // 优先使用historyId字段，其次是id字段，确保与后端API返回格式一致
      const newRecord = {
        id: result.historyId || result.id || Date.now().toString(),
        // 同时保存原始的historyId，确保数据完整性
        historyId: result.historyId,
        timestamp: Date.now(),
        type: result.content?.type || result.type || 'text',
        content: formattedContent,
        moods: this.globalData.selectedMoods
      };
      
      // 确保cachedData和drawHistory存在且drawHistory是数组
      if (!this.globalData.cachedData) {
        this.globalData.cachedData = {};
      }
      
      // 明确检查并修复drawHistory类型
      if (!this.globalData.cachedData.drawHistory) {
        this.globalData.cachedData.drawHistory = [];
      } else if (!Array.isArray(this.globalData.cachedData.drawHistory)) {
        console.warn('drawHistory不是数组类型，已重置为空数组');
        this.globalData.cachedData.drawHistory = [];
      }
      
      // 更新本地缓存
      this.globalData.cachedData.drawHistory.unshift(newRecord);
      
      // 返回保存的记录
      return newRecord;
    } catch (error) {
      console.error('保存历史记录失败:', error);
      return null;
    }
  },

  // 加载抽奖历史（从后端）
  async loadDrawHistory() {
    try {
      const history = await apiService.getDrawHistory();
      this.globalData.cachedData.drawHistory = history || [];
      this.globalData.historyData = history || [];
      return history;
    } catch (error) {
      console.error('加载历史记录失败:', error);
      // 失败时尝试本地模式
      return this.loadLocalDrawHistory();
    }
  },

  // 保存投稿（调用后端API）
  async saveSubmission(submission) {
    try {
      const result = await apiService.submitContribution(submission);
      if (result.success) {
        // 更新本地缓存
        const newSubmission = {
          id: result.id || Date.now().toString(),
          timestamp: Date.now(),
          type: submission.type,
          content: submission.content,
          tags: submission.tags
        };
        
        this.globalData.cachedData.submissions.unshift(newSubmission);
        
        // 刷新用户信息，包含更新后的投稿数和额外抽奖次数
        await this.loadUserInfo();
        
        return newSubmission;
      }
      return null;
    } catch (error) {
      console.error('保存投稿失败:', error);
      // 失败时尝试本地模式
      return this.saveLocalSubmission(submission);
    }
  },

  // 获取投稿状态（从后端）
  async getContributionStatus() {
    try {
      const status = await apiService.getContributionStatus();
      this.globalData.contributionStatus = status || 'pending';
      return status;
    } catch (error) {
      console.error('获取投稿状态失败:', error);
      return 'pending';
    }
  },

  // 获取情绪选项（从后端）
  async getMoodOptions() {
    try {
      const options = await apiService.getMoodOptions();
      return options || ['放松', '开心', '疲惫', '焦虑', '沮丧', '需要鼓励'];
    } catch (error) {
      console.error('获取情绪选项失败:', error);
      return ['放松', '开心', '疲惫', '焦虑', '沮丧', '需要鼓励'];
    }
  },

  // 保存用户信息
  async saveUserInfo(userInfo) {
    try {
      const result = await apiService.updateUserInfo(userInfo);
      if (result.success) {
        this.globalData.userInfo = result.data;
        return true;
      }
      return false;
    } catch (error) {
      console.error('保存用户信息失败:', error);
      // 失败时尝试本地模式
      return this.saveLocalUserInfo(userInfo);
    }
  },

  // 加载用户信息（从后端）
  async loadUserInfo() {
    try {
      const userInfo = await apiService.getUserInfo();
      if (userInfo) {
        this.globalData.userInfo = userInfo;
      }
      return this.globalData.userInfo;
    } catch (error) {
      console.error('加载用户信息失败:', error);
      // 失败时尝试本地模式
      return this.loadLocalUserInfo();
    }
  },

  // ========== 本地模式作为降级方案 ==========
  
  // 初始化本地模式
  initializeLocalMode() {
    try {
      // 初始化历史记录
      if (!this.globalData.cachedData.drawHistory.length) {
        this.globalData.cachedData.drawHistory = wx.getStorageSync('drawHistory') || [];
      }
      
      // 初始化投稿记录
      if (!this.globalData.cachedData.submissions.length) {
        this.globalData.cachedData.submissions = wx.getStorageSync('submissions') || [];
      }
      
      // 加载本地用户信息
      this.loadLocalUserInfo();
    } catch (error) {
      console.error('初始化本地模式失败:', error);
    }
  },

  // 本地模式检查抽奖状态
  checkLocalDrawStatus() {
    try {
      const lastDrawDate = wx.getStorageSync('lastDrawDate');
      const today = new Date().toDateString();
      
      if (lastDrawDate === today) {
        this.globalData.hasDrawnToday = true;
      } else {
        this.globalData.hasDrawnToday = false;
      }
      
      // 加载本地额外抽奖次数
      const extraDraws = wx.getStorageSync('extraDraws') || 0;
      this.globalData.bonusDrawCount = extraDraws;
    } catch (error) {
      console.error('本地检查抽奖状态失败:', error);
    }
  },

  // 本地模式记录抽奖
  recordLocalDraw() {
    try {
      const today = new Date().toDateString();
      wx.setStorageSync('lastDrawDate', today);
      this.globalData.hasDrawnToday = true;
      
      // 这里应该返回一个模拟的抽奖结果
      return {
        type: 'quote',
        content: '生活不止眼前的苟且，还有诗和远方。',
        id: Date.now().toString()
      };
    } catch (error) {
      console.error('本地记录抽奖失败:', error);
      return null;
    }
  },

  // 本地模式使用额外抽奖次数
  useLocalBonusDraw() {
    try {
      const current = wx.getStorageSync('extraDraws') || 0;
      if (current > 0) {
        const newCount = current - 1;
        wx.setStorageSync('extraDraws', newCount);
        this.globalData.bonusDrawCount = newCount;
        
        // 返回模拟结果
        return {
          type: 'image',
          content: '/assets/images/default.jpg',
          id: Date.now().toString()
        };
      }
      return null;
    } catch (error) {
      console.error('本地使用额外抽奖失败:', error);
      return null;
    }
  },

  // 本地模式保存投稿
  saveLocalSubmission(submission) {
    try {
      const submissions = wx.getStorageSync('submissions') || [];
      const newSubmission = {
        id: Date.now().toString(),
        timestamp: Date.now(),
        type: submission.type,
        content: submission.content,
        tags: submission.tags
      };
      
      submissions.unshift(newSubmission);
      wx.setStorageSync('submissions', submissions);
      
      // 更新本地缓存
      this.globalData.cachedData.submissions = submissions;
      
      // 更新用户投稿数
      this.updateLocalUserSubmissionCount();
      
      // 增加本地额外抽奖次数
      this.addLocalBonusDraw();
      
      return newSubmission;
    } catch (error) {
      console.error('本地保存投稿失败:', error);
      return null;
    }
  },

  // 本地模式更新用户投稿数
  updateLocalUserSubmissionCount() {
    try {
      const submissions = wx.getStorageSync('submissions') || [];
      const userInfo = wx.getStorageSync('userInfo') || this.globalData.userInfo;
      userInfo.totalSubmissions = submissions.length;
      wx.setStorageSync('userInfo', userInfo);
      this.globalData.userInfo = userInfo;
    } catch (error) {
      console.error('本地更新用户投稿数失败:', error);
    }
  },

  // 本地模式增加额外抽奖次数
  addLocalBonusDraw(count = 1) {
    try {
      const current = wx.getStorageSync('extraDraws') || 0;
      const newCount = current + count;
      wx.setStorageSync('extraDraws', newCount);
      this.globalData.bonusDrawCount = newCount;
      return newCount;
    } catch (error) {
      console.error('本地增加额外抽奖次数失败:', error);
      return -1;
    }
  },

  // 本地模式保存用户信息
  saveLocalUserInfo(userInfo) {
    try {
      const updatedUserInfo = { ...this.globalData.userInfo, ...userInfo };
      wx.setStorageSync('userInfo', updatedUserInfo);
      this.globalData.userInfo = updatedUserInfo;
      return true;
    } catch (error) {
      console.error('本地保存用户信息失败:', error);
      return false;
    }
  },

  // 本地模式加载用户信息
  loadLocalUserInfo() {
    try {
      const data = wx.getStorageSync('userInfo');
      if (data) {
        this.globalData.userInfo = data;
      }
      return this.globalData.userInfo;
    } catch (error) {
      console.error('本地加载用户信息失败:', error);
      return this.globalData.userInfo;
    }
  },

  // 本地模式加载抽奖历史
  loadLocalDrawHistory() {
    try {
      const history = wx.getStorageSync('drawHistory') || [];
      this.globalData.cachedData.drawHistory = history;
      this.globalData.historyData = history;
      return history;
    } catch (error) {
      console.error('本地加载历史记录失败:', error);
      return [];
    }
  },

  // 清除所有数据（用于测试）
  clearAllData: function() {
    try {
      wx.removeStorageSync('isFirstVisit');
      wx.removeStorageSync('lastDrawDate');
      wx.removeStorageSync('drawHistory');
      wx.removeStorageSync('submissions');
      wx.removeStorageSync('extraDraws');
      wx.removeStorageSync('userInfo');
      wx.removeStorageSync('token');
      
      // 重置全局数据
      this.globalData.isFirstVisit = true;
      this.globalData.hasDrawnToday = false;
      this.globalData.bonusDrawCount = 0;
      this.globalData.historyData = [];
      this.globalData.cachedData.drawHistory = [];
      this.globalData.cachedData.submissions = [];
      
      // 重置API服务的token
      apiService.clearToken();
    } catch (error) {
      console.error('清除数据失败:', error);
    }
  }
})